/**
 * 测试OpenAI工具调用API
 * 
 * 这个脚本用于测试OpenAI工具调用API的功能
 * 使用方法：node test-openai-tools.js
 */

// 导入必要的模块
require('dotenv').config();
const OpenAI = require('openai');

// 初始化OpenAI客户端
const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  baseURL: process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1'
});

// 定义工具
const tools = [
  {
    type: 'function',
    function: {
      name: 'get_current_weather',
      description: '获取指定位置的当前天气',
      parameters: {
        type: 'object',
        properties: {
          location: {
            type: 'string',
            description: '城市名称，例如：北京、上海、广州'
          },
          unit: {
            type: 'string',
            enum: ['celsius', 'fahrenheit'],
            description: '温度单位'
          }
        },
        required: ['location']
      }
    }
  }
];

// 模拟工具执行函数
async function executeFunction(name, args) {
  console.log(`执行函数: ${name}，参数:`, args);
  
  if (name === 'get_current_weather') {
    // 模拟天气数据
    return {
      success: true,
      data: {
        location: args.location,
        temperature: 25,
        unit: args.unit || 'celsius',
        condition: '晴天',
        humidity: 60,
        wind_speed: 10
      },
      message: `成功获取${args.location}的天气信息`
    };
  }
  
  return {
    success: false,
    error: `未知函数: ${name}`
  };
}

// 测试流式API
async function testStreamingAPI() {
  console.log('测试流式API...');
  
  try {
    const stream = await openai.chat.completions.create({
      model: process.env.OPENAI_MODEL || 'gpt-3.5-turbo',
      messages: [
        { role: 'system', content: '你是一个有用的助手。' },
        { role: 'user', content: '北京今天的天气怎么样？' }
      ],
      tools: tools,
      tool_choice: 'auto',
      stream: true
    });
    
    const toolCallsMap = new Map();
    
    for await (const chunk of stream) {
      // 处理内容增量
      if (chunk.choices[0]?.delta?.content) {
        console.log(`内容: ${chunk.choices[0].delta.content}`);
      }
      
      // 处理工具调用
      if (chunk.choices[0]?.delta?.tool_calls) {
        const toolCalls = chunk.choices[0].delta.tool_calls;
        
        for (const toolCall of toolCalls) {
          // 收集工具调用片段
          if (!toolCallsMap.has(toolCall.index)) {
            toolCallsMap.set(toolCall.index, {
              id: toolCall.id,
              function: {
                name: toolCall.function?.name || '',
                arguments: toolCall.function?.arguments || ''
              }
            });
          } else {
            const existingCall = toolCallsMap.get(toolCall.index);
            
            // 合并函数名称和参数
            if (toolCall.function?.name) {
              existingCall.function.name += toolCall.function.name;
            }
            if (toolCall.function?.arguments) {
              existingCall.function.arguments += toolCall.function.arguments;
            }
            if (toolCall.id) {
              existingCall.id = toolCall.id;
            }
          }
          
          // 检查是否有完整的工具调用
          const currentCall = toolCallsMap.get(toolCall.index);
          if (currentCall && currentCall.function.name && currentCall.function.arguments) {
            try {
              // 尝试解析参数，如果成功则说明参数已完整
              JSON.parse(currentCall.function.arguments);
              
              // 标记为已处理，避免重复处理
              if (!currentCall.processed) {
                currentCall.processed = true;
                
                const name = currentCall.function.name;
                const args = currentCall.function.arguments;
                
                console.log(`完整的工具调用: ${name}，参数: ${args}`);
                
                // 执行函数
                try {
                  const parsedArgs = JSON.parse(args);
                  const result = await executeFunction(name, parsedArgs);
                  console.log('函数执行结果:', result);
                  
                  // 提交工具调用结果
                  if (currentCall.id) {
                    await openai.chat.completions.create({
                      model: process.env.OPENAI_MODEL || 'gpt-3.5-turbo',
                      messages: [
                        { role: 'system', content: '你是一个有用的助手。' },
                        { role: 'user', content: '北京今天的天气怎么样？' },
                        {
                          role: 'assistant',
                          tool_calls: [{
                            id: currentCall.id,
                            type: 'function',
                            function: { name, arguments: args }
                          }]
                        },
                        {
                          role: 'tool',
                          tool_call_id: currentCall.id,
                          content: JSON.stringify(result)
                        }
                      ],
                      stream: false
                    });
                    console.log('工具调用结果已提交');
                  }
                } catch (error) {
                  console.error('函数执行错误:', error);
                }
              }
            } catch (jsonError) {
              // JSON解析错误，说明参数不完整，继续等待更多数据
              console.log('参数不完整，继续等待...');
            }
          }
        }
      }
      
      // 检查是否完成
      if (chunk.choices[0]?.finish_reason === 'stop') {
        console.log('流式响应完成');
      }
    }
    
    console.log('流式API测试完成');
  } catch (error) {
    console.error('流式API测试失败:', error);
  }
}

// 运行测试
async function runTests() {
  console.log('开始测试OpenAI工具调用API...');
  await testStreamingAPI();
  console.log('测试完成');
}

runTests().catch(console.error);
